// pages/index/index.js
const app = getApp()

Page({
  data: {
    userInfo: {},
    hasUserInfo: false,
    canIUse: wx.canIUse('button.open-type.getUserInfo'),
    unreadCount: 0,
    showNotificationModal: false,
    notificationList: [],
    currentPage: 1,
    pageSize: 5,
    totalPages: 0,
    loading: false,
    banners: [],
    bannerLoading: false,
    services: [
      {
        id: 'labor',
        name: '劳务服务',
        icon: '💼',
        desc: '多样化劳务服务，赚取收入',
        path: '/pages/labor/list/list'
      }
    ],
    stats: {
      totalServices: 0,
      todayServices: 0,
      totalUsers: 0
    },
    hotRecommends: [],
    // 热门推荐分页相关
    currentRecommendPage: 1,
    recommendPageSize: 10,
    hasMoreRecommends: true,
    recommendLoading: false,
    isInitialLoad: true
  },

  onLoad() {
    // 允许未登录用户浏览首页
    if (app.globalData.userInfo) {
      this.setData({
        userInfo: app.globalData.userInfo,
        hasUserInfo: true
      })
    } else if (this.data.canIUse) {
      app.userInfoReadyCallback = res => {
        this.setData({
          userInfo: res.userInfo,
          hasUserInfo: true
        })
      }
    } else {
      wx.getUserInfo({
        success: res => {
          app.globalData.userInfo = res.userInfo
          this.setData({
            userInfo: res.userInfo,
            hasUserInfo: true
          })
        }
      })
    }

    // 加载统计数据
    this.loadStats()
    // 加载轮播图
    this.loadBanners()
  },

  onShow() {
    // 设置tabBar选中状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 0
      })
    }
    
    // 加载公开数据（无需登录）
    this.loadStats()
    this.loadBanners()
    this.loadHotRecommends()
    
    // 如果已登录，更新未读消息数
    if (app.utils.checkLoginStatus()) {
      this.loadUnreadCount()
    }
  },

  loadUnreadCount() {
    // 模拟获取未读消息数，包括劳务接单通知
    setTimeout(() => {
      // 模拟从服务器获取各种类型的未读消息
      const laborNotifications = this.getLaborNotifications()
      const systemMessages = this.getSystemMessages()
      const chatMessages = this.getChatMessages()
      
      const totalUnread = laborNotifications.length + systemMessages.length + chatMessages.length
      
    this.setData({
        unreadCount: totalUnread
      })
      
      // 将未读消息存储到本地，供消息页面使用
      wx.setStorageSync('unreadMessages', {
        labor: laborNotifications,
        system: systemMessages,
        chat: chatMessages
      })
    }, 500)
  },

  getLaborNotifications() {
    // 模拟劳务接单通知数据
    return [
      {
        id: 'labor_1',
        type: 'labor_accepted',
        laborId: '123',
        laborTitle: '图书馆整理书籍',
        applicantName: '张同学',
        applicantAvatar: '/images/avatar-default.png',
        applicationTime: '2024-01-15 14:30',
        applicationNote: '我有相关经验，可以胜任这份工作',
        salary: '50',
        isRead: false
      },
      {
        id: 'labor_2', 
        type: 'labor_accepted',
        laborId: '124',
        laborTitle: '数学家教辅导',
        applicantName: '李同学',
        applicantAvatar: '/images/avatar-default.png',
        applicationTime: '2024-01-15 16:20',
        applicationNote: '数学专业，有家教经验',
        salary: '80',
        isRead: false
      }
    ]
  },

  getSystemMessages() {
    // 模拟系统消息
    return [
      {
        id: 'sys_1',
        type: 'system',
        content: '您的账户余额不足，请及时充值',
        time: '2024-01-15 10:00',
        isRead: false
      }
    ]
  },

  getChatMessages() {
    // 模拟聊天消息
    return []
  },

  // 加载统计数据
  async loadStats() {
    try {
      // 并行获取统计数据
      const [laborStatsResult, totalUsersResult] = await Promise.allSettled([
        this.getLaborStats(),
        this.getTotalUsersCount()
      ])

      // 更新统计数据
      this.setData({
        'stats.totalServices': this.extractLaborStats(laborStatsResult, 'totalCount'),
        'stats.todayServices': this.extractLaborStats(laborStatsResult, 'todayCount'),
        'stats.totalUsers': this.extractCount(totalUsersResult)
      })
    } catch (error) {
      console.error('加载统计数据失败:', error)
      // 如果API调用失败，使用模拟数据
      this.setData({
        stats: {
          totalServices: 0,
          todayServices: 0,
          totalUsers: 0
        }
      })
    }
    
    // 初始加载热门推荐
    this.loadHotRecommends()
  },

  // 获取劳务统计信息
  async getLaborStats() {
    try {
      console.log('开始获取劳务统计信息...')
      
      const result = await app.utils.request({
        url: '/labor/stats',
        method: 'GET'
      })
      
      console.log('劳务统计API结果:', result)
      return result
    } catch (error) {
      console.error('获取劳务统计失败:', error)
      return null
    }
  },

  // 获取总用户数
  async getTotalUsersCount() {
    try {
      const result = await app.utils.request({
        url: '/auth/users/count',
        method: 'GET'
      })
      return result
    } catch (error) {
      console.error('获取用户总数失败:', error)
      return null
    }
  },

  // 获取热门推荐（分页查询所有未完成的任务）
  async getHotRecommends(page = 1, size = 10) {
    try {
      const result = await app.utils.request({
        url: `/labor/hot?page=${page}&size=${size}&status=recruiting`, // 分页查询未完成任务
        method: 'GET'
      })
      return result
    } catch (error) {
      console.error('获取热门推荐失败:', error)
      return null
    }
  },

  // 获取单个服务类型的数量（辅助方法）
  async getServiceCount(url) {
    try {
      console.log(`调用API: ${url}`)
      const result = await app.utils.request({
        url: url,
        method: 'GET'
      })
      console.log(`API ${url} 返回结果:`, result)
      return result
    } catch (error) {
      console.error(`获取服务统计数据失败: ${url}`, error)
      return null
    }
  },

  // 从API结果中提取数量
  extractCount(result) {
    console.log('extractCount 输入:', result)
    
    if (result && result.status === 'fulfilled' && result.value && result.value.code === 200) {
      console.log('API调用成功，data:', result.value.data)
      
      // 如果data是对象且有total字段，返回total
      if (result.value.data && typeof result.value.data === 'object' && result.value.data.total !== undefined) {
        console.log('提取total字段:', result.value.data.total)
        return result.value.data.total || 0
      }
      // 如果data直接是数字，返回该数字
      if (typeof result.value.data === 'number') {
        console.log('提取数字:', result.value.data)
        return result.value.data
      }
    }
    
    console.log('无法提取数量，返回0')
    return 0
  },

  // 从劳务统计API结果中提取数据
  extractLaborStats(result, field) {
    console.log('extractLaborStats 输入:', result, '字段:', field)
    
    if (result && result.status === 'fulfilled' && result.value && result.value.code === 200) {
      console.log('劳务统计API调用成功，data:', result.value.data)
      
      if (result.value.data && typeof result.value.data === 'object' && result.value.data[field] !== undefined) {
        console.log(`提取${field}字段:`, result.value.data[field])
        return result.value.data[field] || 0
      }
    }
    
    console.log(`无法提取${field}字段，返回0`)
    return 0
  },

  // 加载热门推荐（分页）
  async loadHotRecommends(isLoadMore = false) {
    if (this.data.recommendLoading) {
      return
    }
    
    this.setData({ recommendLoading: true })
    
    try {
      const { currentRecommendPage, recommendPageSize } = this.data
      const page = isLoadMore ? currentRecommendPage : 1
      
      console.log(`加载热门推荐 - 第${page}页`)
      
      const result = await this.getHotRecommends(page, recommendPageSize)
      
      if (result && result.code === 200) {
        const newData = this.extractHotRecommends(result)
        const hasMore = newData.length === recommendPageSize // 如果返回数据等于页面大小，说明可能还有更多数据
        
        if (isLoadMore) {
          // 加载更多：追加数据
          this.setData({
            hotRecommends: [...this.data.hotRecommends, ...newData],
            currentRecommendPage: page + 1,
            hasMoreRecommends: hasMore,
            recommendLoading: false
          })
        } else {
          // 初始加载：替换数据
          this.setData({
            hotRecommends: newData,
            currentRecommendPage: 2,
            hasMoreRecommends: hasMore,
            recommendLoading: false,
            isInitialLoad: false
          })
        }
        
        console.log(`热门推荐加载完成，当前页：${page}，数据量：${newData.length}，还有更多：${hasMore}`)
      } else {
        throw new Error(result?.message || '获取热门推荐失败')
      }
    } catch (error) {
      console.error('加载热门推荐失败:', error)
      
      // 如果是初始加载失败，使用默认数据
      if (!isLoadMore && this.data.isInitialLoad) {
        const defaultData = this.getDefaultHotRecommends()
        this.setData({
          hotRecommends: defaultData,
          currentRecommendPage: 2,
          hasMoreRecommends: false,
          isInitialLoad: false
        })
      }
      
      this.setData({ recommendLoading: false })
      
      if (!this.data.isInitialLoad) {
        wx.showToast({
          title: isLoadMore ? '加载失败' : '刷新失败',
          icon: 'none'
        })
      }
    }
  },

  // 从API结果中提取热门推荐数据
  extractHotRecommends(apiResult) {
    // 处理分页结果
    let labors = []
    
    if (apiResult && apiResult.data) {
      // 如果是分页结果（有records字段）
      if (apiResult.data.records && Array.isArray(apiResult.data.records)) {
        labors = apiResult.data.records
      }
      // 如果是直接的数组
      else if (Array.isArray(apiResult.data)) {
        labors = apiResult.data
      }
    }
    
      return labors.map(labor => ({
        id: labor.id,
        jobTitle: labor.jobTitle || '劳务服务',
        title: labor.jobTitle || '劳务服务', // 兼容旧字段
      description: labor.description || '暂无描述',
        salary: labor.salary || 0,
        price: labor.salary || 0, // 兼容旧字段
        createTime: this.formatTime(labor.createTime),
        time: this.formatTime(labor.createTime), // 兼容旧字段
        status: labor.status,
        statusText: this.getStatusText(labor.status),
      viewCount: labor.viewCount || 0,
      applicationCount: labor.applicationCount || 0,
        // 新增劳务类型相关字段
        typeName: labor.typeName,
        typeIcon: labor.typeIcon,
        typeColor: labor.typeColor,
        typeId: labor.typeId,
        // 其他相关字段
        location: labor.location,
        workType: labor.workType,
        workTypeText: this.getWorkTypeText(labor.workType),
        isUrgent: labor.urgent === 1 || labor.isUrgent,
        publisherName: labor.publisherName || labor.publisher,
        publisher: labor.publisherName || labor.publisher,
        // 发布者类型字段
        publisherType: labor.publisherType, // 'student' 或 'merchant'
        publisherTypeText: this.getPublisherTypeText(labor.publisherType),
        publisherTypeIcon: this.getPublisherTypeIcon(labor.publisherType)
    }))
  },

  // 获取默认热门推荐数据
  getDefaultHotRecommends() {
    return [
      {
        id: 1,
        jobTitle: '家教辅导数学',
        title: '家教辅导数学',
        description: '需要数学基础扎实，有耐心，能够帮助学生提高数学成绩',
        salary: 80,
        price: 80,
        createTime: '1小时前',
        time: '1小时前',
        status: 'recruiting',
        statusText: '招聘中',
        viewCount: 156,
        applicationCount: 8,
        typeName: '家教辅导',
        typeIcon: '📚',
        typeColor: '#10b981',
        location: '图书馆',
        workType: 'part-time',
        workTypeText: '兼职',
        isUrgent: false,
        publisherName: '张同学'
      },
      {
        id: 2,
        jobTitle: '兼职客服',
        title: '兼职客服',
        description: '负责在线客服工作，回复用户咨询，处理订单问题',
        salary: 50,
        price: 50,
        createTime: '2小时前',
        time: '2小时前',
        status: 'recruiting',
        statusText: '招聘中',
        viewCount: 89,
        applicationCount: 5,
        typeName: '兼职工作',
        typeIcon: '💼',
        typeColor: '#3b82f6',
        location: '线上办公',
        workType: 'part-time',
        workTypeText: '兼职',
        isUrgent: false,
        publisherName: '李老板'
      },
      {
        id: 3,
        jobTitle: '设计师助理',
        title: '设计师助理', 
        description: '协助完成平面设计工作，制作海报、宣传册等',
        salary: 100,
        price: 100,
        createTime: '3小时前',
        time: '3小时前',
        status: 'recruiting',
        statusText: '招聘中',
        viewCount: 234,
        applicationCount: 15,
        typeName: '创意设计',
        typeIcon: '🎨',
        typeColor: '#ec4899',
        location: '设计工作室',
        workType: 'part-time',
        workTypeText: '兼职',
        isUrgent: true,
        publisherName: '设计公司'
      }
    ]
  },

  // 从API结果中提取热门推荐数据
  extractHotRecommends(apiResult) {
    // 处理分页结果
    let labors = []
    
    if (apiResult && apiResult.data) {
      // 如果是分页结果（有records字段）
      if (apiResult.data.records && Array.isArray(apiResult.data.records)) {
        labors = apiResult.data.records
      }
      // 如果是直接的数组
      else if (Array.isArray(apiResult.data)) {
        labors = apiResult.data
      }
    }
    
    return labors.map(labor => ({
      id: labor.id,
      jobTitle: labor.jobTitle || '劳务服务',
      title: labor.jobTitle || '劳务服务', // 兼容旧字段
      description: labor.description || '暂无描述',
      salary: labor.salary || 0,
      price: labor.salary || 0, // 兼容旧字段
      createTime: this.formatTime(labor.createTime),
      time: this.formatTime(labor.createTime), // 兼容旧字段
      status: labor.status,
      statusText: this.getStatusText(labor.status),
      viewCount: labor.viewCount || 0,
      applicationCount: labor.applicationCount || 0,
      // 新增劳务类型相关字段
      typeName: labor.typeName,
      typeIcon: labor.typeIcon,
      typeColor: labor.typeColor,
      typeId: labor.typeId,
      // 其他相关字段
      location: labor.location,
      workType: labor.workType,
      workTypeText: this.getWorkTypeText(labor.workType),
      isUrgent: labor.urgent === 1 || labor.isUrgent,
      publisherName: labor.publisherName || labor.publisher,
      publisher: labor.publisherName || labor.publisher
    }))
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'recruiting': '招聘中',
      'filled': '已招满',
      'closed': '已关闭',
      'completed': '已完成',
      'cancelled': '已取消'
    }
    return statusMap[status] || '招聘中'
  },

  getWorkTypeText(workType) {
    const typeMap = {
      'one-off': '一次性',
      'part-time': '兼职',
      'full-time': '全职'
    }
    return typeMap[workType] || workType || '未知'
  },

  // 获取发布者类型文本
  getPublisherTypeText(publisherType) {
    const typeMap = {
      'student': '学生发布',
      'merchant': '商户发布'
    }
    return typeMap[publisherType] || ''
  },

  // 获取发布者类型图标
  getPublisherTypeIcon(publisherType) {
    const iconMap = {
      'student': '🎓',
      'merchant': '🏪'
    }
    return iconMap[publisherType] || ''
  },

  navigateToService(e) {
    const path = e.currentTarget.dataset.path
    
    if (!path) {
      wx.showToast({
        title: '页面路径不存在',
        icon: 'none'
      })
      return
    }

    wx.navigateTo({
      url: path
    })
  },

  navigateToMessages() {
    // 检查登录状态
    if (!app.utils.checkLoginStatus()) {
      this.promptLogin('查看消息需要登录')
      return
    }
    // 显示通知列表弹窗
    this.showNotificationList()
  },

  navigateToDetail(e) {
    const id = e.currentTarget.dataset.id
    
    if (!id) {
      wx.showToast({
        title: '任务ID不存在',
        icon: 'none'
      })
      return
    }

    // 所有推荐都导向劳务详情页面
    wx.navigateTo({
      url: `/pages/labor/detail/detail?id=${id}`
    })
  },

  navigateToPublish() {
    // 检查登录状态
    if (!app.utils.checkLoginStatus()) {
      this.promptLogin('发布任务需要登录')
      return
    }
    // 直接跳转到统一的发布页面
    wx.navigateTo({
      url: '/pages/publish/publish'
    })
  },

  // 提示用户登录
  promptLogin(message = '请先登录以使用完整功能') {
    wx.showModal({
      title: '需要登录',
      content: message,
      confirmText: '去登录',
      cancelText: '继续浏览',
      success: (res) => {
        if (res.confirm) {
          wx.navigateTo({
            url: '/pages/login/login'
          })
        }
      }
    })
  },

  // 格式化时间
  formatTime(createTime) {
    if (!createTime) return '刚刚'
    
    const now = new Date()
    const time = new Date(createTime)
    const diff = now - time
    
    const minutes = Math.floor(diff / (1000 * 60))
    const hours = Math.floor(diff / (1000 * 60 * 60))
    const days = Math.floor(diff / (1000 * 60 * 60 * 24))
    
    if (minutes < 60) {
      return minutes <= 0 ? '刚刚' : `${minutes}分钟前`
    } else if (hours < 24) {
      return `${hours}小时前`
    } else {
      return `${days}天前`
    }
  },

  // 获取状态文本
  getStatusText(status) {
    const statusMap = {
      'recruiting': '招聘中',
      'filled': '已招满',
      'closed': '已关闭',
      'completed': '已完成',
      'cancelled': '已取消'
    }
    return statusMap[status] || '招聘中'
  },

  getWorkTypeText(workType) {
    const typeMap = {
      'one-off': '一次性',
      'part-time': '兼职',
      'full-time': '全职'
    }
    return typeMap[workType] || workType || '未知'
  },

  async getUserInfo(e) {
    console.log('获取用户信息:', e)

    if (!e.detail.userInfo) {
      app.utils.showError('获取用户信息失败')
      return
    }

    try {
      app.utils.showLoading('登录中...')

      // 1. 获取微信登录凭证
      const code = await app.utils.wechatLogin()

      // 2. 调用后端登录接口
      const loginResult = await app.utils.request({
        url: '/auth/wechat/login',
        method: 'POST',
        data: { code }
      })

      // 3. 保存登录信息和sessionKey
      app.utils.saveUserInfo(loginResult.data.student, loginResult.data.token)
      // 保存sessionKey用于后续解密用户信息
      wx.setStorageSync('sessionKey', loginResult.data.sessionKey)

      // 4. 更新页面显示
      this.setData({
        userInfo: loginResult.data.student,
        hasUserInfo: true
      })

      app.utils.hideLoading()
      app.utils.showSuccess('登录成功')

      // 5. 提示用户是否获取头像和昵称
      wx.showModal({
        title: '获取用户信息',
        content: '为了更好的服务体验，是否获取您的微信头像和昵称？',
        success: (res) => {
          if (res.confirm) {
            this.updateUserProfile()
          }
        }
      })

    } catch (error) {
      console.error('登录失败:', error)
      app.utils.hideLoading()
      app.utils.showError(error.message || '登录失败，请重试')
    }
  },

  // 更新用户资料
  async updateUserProfile() {
    try {
      app.utils.showLoading('更新用户信息...')

      // 获取用户信息
      const userProfile = await app.utils.getUserProfile()
      console.log('获取到用户信息:', userProfile.userInfo)
      console.log('获取到加密数据:', userProfile.encryptedData)
      console.log('获取到初始向量:', userProfile.iv)

      // 获取保存的sessionKey
      const sessionKey = wx.getStorageSync('sessionKey')
      if (!sessionKey) {
        throw new Error('sessionKey不存在，请重新登录')
      }

      // 调用后端更新用户信息接口
      const updateResult = await app.utils.request({
        url: '/auth/user/update',
        method: 'POST',
        data: {
          encryptedData: userProfile.encryptedData,
          sessionKey: sessionKey,
          iv: userProfile.iv
        }
      })

      if (updateResult.code === 200) {
        // 使用后端返回的更新后的用户信息
        app.utils.saveUserInfo(updateResult.data, app.globalData.token)

        // 更新页面显示
        this.setData({
          userInfo: updateResult.data,
          hasUserInfo: true
        })
        app.utils.showSuccess('用户信息更新成功')
      }

      app.utils.hideLoading()
    } catch (error) {
      console.error('更新用户信息失败:', error)
      app.utils.hideLoading()
      app.utils.showError('更新用户信息失败')
    }
  },

  navigateToService(e) {
    const path = e.currentTarget.dataset.path
    
    if (!path) {
      wx.showToast({
        title: '页面路径不存在',
        icon: 'none'
      })
      return
    }

    wx.navigateTo({
      url: path
    })
  },

  navigateToMessages() {
    // 检查登录状态
    if (!app.utils.checkLoginStatus()) {
      this.promptLogin('查看消息需要登录')
      return
    }
    // 显示通知列表弹窗
    this.showNotificationList()
  },

  showNotificationList() {
    this.setData({
      showNotificationModal: true,
      currentPage: 1
    })
    this.loadNotificationList()
  },

  hideNotificationList() {
    this.setData({
      showNotificationModal: false,
      notificationList: []
    })
  },

  loadNotificationList() {
    this.setData({ loading: true })
    
    setTimeout(() => {
      // 获取所有通知数据
      const allNotifications = this.getAllNotifications()
      const { currentPage, pageSize } = this.data
      
      // 计算分页数据
      const totalCount = allNotifications.length
      const totalPages = Math.ceil(totalCount / pageSize)
      const startIndex = (currentPage - 1) * pageSize
      const endIndex = startIndex + pageSize
      const pageData = allNotifications.slice(startIndex, endIndex)
      
      this.setData({
        notificationList: pageData,
        totalPages,
        loading: false
      })
    }, 500)
  },

  getAllNotifications() {
    // 获取所有类型的通知
    const laborNotifications = this.getLaborNotifications()
    const systemMessages = this.getSystemMessages()
    const chatMessages = this.getChatMessages()
    
    // 合并所有通知并按时间排序
    const allNotifications = [
      ...laborNotifications.map(item => ({
        ...item,
        type: 'labor',
        time: item.applicationTime,
        title: `${item.applicantName} 申请了您的劳务`,
        preview: `工作：${item.laborTitle} | 薪资：¥${item.salary}`,
        avatar: item.applicantAvatar
      })),
      ...systemMessages.map(item => ({
        ...item,
        type: 'system',
        title: '系统消息',
        preview: item.content,
        avatar: ''
      })),
      ...chatMessages.map(item => ({
        ...item,
        type: 'chat',
        title: item.sender,
        preview: item.content,
        avatar: item.avatar
      }))
    ]
    
    // 按时间倒序排列
    return allNotifications.sort((a, b) => new Date(b.time) - new Date(a.time))
  },

  onPageChange(e) {
    const { type } = e.currentTarget.dataset
    let { currentPage, totalPages } = this.data
    
    if (type === 'prev' && currentPage > 1) {
      currentPage--
    } else if (type === 'next' && currentPage < totalPages) {
      currentPage++
    }
    
    this.setData({ currentPage })
    this.loadNotificationList()
  },

  onNotificationTap(e) {
    const { item } = e.currentTarget.dataset
    
    // 处理不同类型通知的点击事件
    switch (item.type) {
      case 'labor':
        this.showLaborDetail(item)
        break
      case 'system':
        this.showSystemDetail(item)
        break
      case 'chat':
        this.openChat(item)
        break
    }
  },

  showLaborDetail(item) {
    wx.showModal({
      title: '💼 劳务申请详情',
      content: `申请人：${item.applicantName}\n工作：${item.laborTitle}\n薪资：¥${item.salary}\n时间：${item.applicationTime}\n\n申请说明：\n${item.applicationNote}`,
      confirmText: '查看申请者',
      cancelText: '稍后处理',
      success: (res) => {
        if (res.confirm) {
          // 关闭通知列表并跳转
          this.hideNotificationList()
          wx.navigateTo({
            url: `/pages/labor/applicants/applicants?laborId=${item.laborId}`
          })
        }
      }
    })
  },

  showSystemDetail(item) {
    wx.showModal({
      title: '🔔 系统消息',
      content: item.content,
      showCancel: false,
      confirmText: '知道了'
    })
  },

  openChat(item) {
    this.hideNotificationList()
    wx.navigateTo({
      url: `/pages/user/chat/chat?userId=${item.userId}&userName=${item.sender}`
    })
  },

  goToAllMessages() {
    this.hideNotificationList()
    wx.navigateTo({
      url: '/pages/user/messages/messages'
    })
  },

  navigateToDetail(e) {
    const id = e.currentTarget.dataset.id
    
    if (!id) {
      wx.showToast({
        title: '任务ID不存在',
        icon: 'none'
      })
      return
    }

    // 所有推荐都导向劳务详情页面
      wx.navigateTo({
      url: `/pages/labor/detail/detail?id=${id}`
      })
  },

  navigateToPublish() {
    // 直接跳转到统一的发布页面
        wx.navigateTo({
      url: '/pages/publish/publish'
    })
  },

  // 加载轮播图数据
  async loadBanners() {
    this.setData({ bannerLoading: true })
    
    try {
      console.log('开始加载轮播图数据...')
      
      const result = await app.utils.request({
        url: '/banners',
        method: 'GET',
        data: {
          status: 1, // 只获取启用的轮播图
          page: 1,
          size: 10
        }
      })
  
      
      if (result && result.code === 200) {
        const banners = result.data.records || result.data || []
        console.log('解析后的轮播图数据:', banners)
        this.setData({
          banners: banners,
          bannerLoading: false
        })
        console.log('轮播图加载成功，数量:', banners.length)
        console.log('设置后的banners:', this.data.banners)
      } else {
        throw new Error(result.message || '获取轮播图失败')
      }
    } catch (error) {
      console.error('加载轮播图失败:', error)
      // 使用模拟数据
      const defaultBanners = this.getDefaultBanners()
      console.log('使用默认轮播图数据:', defaultBanners)
      this.setData({
        banners: defaultBanners,
        bannerLoading: false
      })
      console.log('设置默认数据后的banners:', this.data.banners)
    }
  },

  // 获取默认轮播图数据
  getDefaultBanners() {
    return [
      {
        id: 1,
        title: '校园活动季',
        description: '精彩活动，不容错过！',
        imageUrl: 'https://via.placeholder.com/750x300/667eea/ffffff?text=校园活动季',
        linkUrl: 'https://example.com/activity1',
        sortOrder: 1,
        status: 1
      },
      {
        id: 2,
        title: '新生入学指南',
        description: '助你快速融入大学生活',
        imageUrl: 'https://via.placeholder.com/750x300/4facfe/ffffff?text=新生入学指南',
        linkUrl: 'https://example.com/freshman',
        sortOrder: 2,
        status: 1
      },
      {
        id: 3,
        title: '兼职招聘',
        description: '海量兼职等你来',
        imageUrl: 'https://via.placeholder.com/750x300/43e97b/ffffff?text=兼职招聘',
        linkUrl: 'https://example.com/jobs',
        sortOrder: 3,
        status: 1
      }
    ]
  },

  // 轮播图点击事件
  onBannerTap(e) {
    const banner = e.currentTarget.dataset.banner
    
    if (!banner || !banner.linkUrl) {
      console.log('轮播图无跳转链接')
      return
    }

    // 检查链接类型
    if (banner.linkUrl.startsWith('http://') || banner.linkUrl.startsWith('https://')) {
      // 外部链接，复制到剪贴板
      wx.setClipboardData({
        data: banner.linkUrl,
        success: () => {
          wx.showToast({
            title: '链接已复制',
            icon: 'success'
          })
        }
      })
    } else if (banner.linkUrl.startsWith('/pages/')) {
      // 内部页面跳转
      wx.navigateTo({
        url: banner.linkUrl,
        fail: () => {
          wx.showToast({
            title: '页面跳转失败',
            icon: 'none'
          })
        }
      })
    } else {
      // 其他情况，显示轮播图详情
      wx.showModal({
        title: banner.title,
        content: banner.description || '暂无描述',
        showCancel: false,
        confirmText: '知道了'
      })
    }
  },

  // 图片加载成功
  onImageLoad(e) {
    console.log('轮播图图片加载成功:', e.detail)
  },

  // 图片加载失败
  onImageError(e) {
    console.error('轮播图图片加载失败:', e.detail)
    console.error('失败的图片URL:', e.currentTarget.src)
    wx.showToast({
      title: '图片加载失败',
      icon: 'none'
    })
  },

  // 触底事件处理 - 加载更多热门推荐
  onReachBottom() {
    console.log('触底事件触发')
    if (this.data.hasMoreRecommends && !this.data.recommendLoading) {
      console.log('开始加载更多热门推荐')
      this.loadHotRecommends(true)
    } else {
      console.log('没有更多数据或正在加载中')
    }
  },

  // 下拉刷新
  onPullDownRefresh() {
    console.log('下拉刷新触发')
    
    // 重置分页状态
    this.setData({
      hotRecommends: [],
      currentRecommendPage: 1,
      hasMoreRecommends: true,
      recommendLoading: false,
      isInitialLoad: false
    })
    
    // 重新加载数据
    Promise.all([
      this.loadStats(),
      this.loadUnreadCount()
    ]).finally(() => {
      // 停止下拉刷新动画
      wx.stopPullDownRefresh()
    })
  },

  // 页面滚动事件处理（可选：提前加载）
  onPageScroll(e) {
    // 当滚动到距离底部200px时，提前加载下一页数据
    const threshold = 200
    const { scrollTop } = e
    
    wx.createSelectorQuery().select('.container').boundingClientRect((rect) => {
      if (rect) {
        const { height: containerHeight } = rect
        const systemInfo = wx.getSystemInfoSync()
        const { windowHeight } = systemInfo
        
        // 计算是否接近底部
        if (scrollTop + windowHeight >= containerHeight - threshold) {
          if (this.data.hasMoreRecommends && !this.data.recommendLoading) {
            console.log('提前加载更多数据')
            this.loadHotRecommends(true)
          }
        }
      }
    }).exec()
  }
})
